  import type {IMenuProps} from '@/interface/common'
  
  // 通过子路由path 找父路由path, 是先通过menu的数据去找
  // menuList: 菜单接口取读
  export function getParentPath(path:string,menuList:IMenuProps[]):IMenuProps {
    // 根据子路由找父路由对象
    var menuObj = {} as IMenuProps   //父路由
    function testFun(menus:IMenuProps[], path:string) {
        menus.forEach((item) => {
            // children子路下是否有目标path
            let usItem = item.children?.find((option) => {
                return option.path == path
            })
            //    usItem  : 这个当前含有path的那个对象， 我需要他的父
            if (usItem) {
                menuObj = item;// 只可能进来一次，因为path是唯一的
            } else {
                item.children && testFun(item.children, path)
            }
        })
    }
    // 外层的变量 menuList传入里面的闭包函数
    testFun(menuList, path)
    return menuObj;
  }

// 根据已知的path , 收集他的父的对象, 用来存放面包屑
export function getRouterMenu(curPath:string,menuList:IMenuProps[]) {
    var arrObj:string[] = [];  // 用来存放面包屑
    function testMenu(path:string) {
        var parentObj = getParentPath(path,menuList);
        if (parentObj.path) {
            // 找到父对象
            arrObj.push(parentObj.name);
            testMenu(parentObj.path);
        }
    }
    testMenu(curPath);

    return arrObj.reverse();
}

// 根据已知的path ,获取当前的路由对象
export function getCurPathObj(path:string,menuList:IMenuProps[]):IMenuProps {
    let routerObj = {} as IMenuProps;  // 污染全局变量
    // hasRoute 是一个闭包函数。 闭包函数中使用的变量isRouter 没有销毁， 在内存中
    function RouteFun(menus:IMenuProps[], path:string) {
        // 循环 find , forEach , findIndex 
        menus.forEach((item) => {
            if (item.path == path) {
                routerObj = item;  // 当前你找到的这个路由对象
            } else {
                item.children && RouteFun(item.children, path)
            }
        })
    }
    // 调用hasRoute函数， 找到相应的path
    RouteFun(menuList, path)
    return routerObj
  }